/*
 * Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.beans;

import com.sun.beans.TypeResolver;
import com.sun.beans.WeakCache;
import com.sun.beans.finder.ClassFinder;
import com.sun.beans.finder.MethodFinder;

import java.awt.Component;

import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;

import java.util.Map;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.EventListener;
import java.util.EventObject;
import java.util.List;
import java.util.TreeMap;

import sun.reflect.misc.ReflectUtil;

/**
 * The Introspector class provides a standard way for tools to learn about the properties, events,
 * and methods supported by a target Java Bean. <p> For each of those three kinds of information,
 * the Introspector will separately analyze the bean's class and superclasses looking for either
 * explicit or implicit information and use that information to build a BeanInfo object that
 * comprehensively describes the target bean. <p> For each class "Foo", explicit information may be
 * available if there exists a corresponding "FooBeanInfo" class that provides a non-null value when
 * queried for the information.   We first look for the BeanInfo class by taking the full
 * package-qualified name of the target bean class and appending "BeanInfo" to form a new class
 * name.  If this fails, then we take the final classname component of this name, and look for that
 * class in each of the packages specified in the BeanInfo package search path. <p> Thus for a class
 * such as "sun.xyz.OurButton" we would first look for a BeanInfo class called
 * "sun.xyz.OurButtonBeanInfo" and if that failed we'd look in each package in the BeanInfo search
 * path for an OurButtonBeanInfo class.  With the default search path, this would mean looking for
 * "sun.beans.infos.OurButtonBeanInfo". <p> If a class provides explicit BeanInfo about itself then
 * we add that to the BeanInfo information we obtained from analyzing any derived classes, but we
 * regard the explicit information as being definitive for the current class and its base classes,
 * and do not proceed any further up the superclass chain. <p> If we don't find explicit BeanInfo on
 * a class, we use low-level reflection to study the methods of the class and apply standard design
 * patterns to identify property accessors, event sources, or public methods.  We then proceed to
 * analyze the class's superclass and add in the information from it (and possibly on up the
 * superclass chain). <p> For more information about introspection and design patterns, please
 * consult the <a href="http://www.oracle.com/technetwork/java/javase/documentation/spec-136004.html">JavaBeans&trade;
 * specification</a>.
 */

public class Introspector {

  // Flags that can be used to control getBeanInfo:
  /**
   * Flag to indicate to use of all beaninfo.
   */
  public final static int USE_ALL_BEANINFO = 1;
  /**
   * Flag to indicate to ignore immediate beaninfo.
   */
  public final static int IGNORE_IMMEDIATE_BEANINFO = 2;
  /**
   * Flag to indicate to ignore all beaninfo.
   */
  public final static int IGNORE_ALL_BEANINFO = 3;

  // Static Caches to speed up introspection.
  private static final WeakCache<Class<?>, Method[]> declaredMethodCache = new WeakCache<>();

  private Class<?> beanClass;
  private BeanInfo explicitBeanInfo;
  private BeanInfo superBeanInfo;
  private BeanInfo additionalBeanInfo[];

  private boolean propertyChangeSource = false;
  private static Class<EventListener> eventListenerType = EventListener.class;

  // These should be removed.
  private String defaultEventName;
  private String defaultPropertyName;
  private int defaultEventIndex = -1;
  private int defaultPropertyIndex = -1;

  // Methods maps from Method names to MethodDescriptors
  private Map<String, MethodDescriptor> methods;

  // properties maps from String names to PropertyDescriptors
  private Map<String, PropertyDescriptor> properties;

  // events maps from String names to EventSetDescriptors
  private Map<String, EventSetDescriptor> events;

  private final static EventSetDescriptor[] EMPTY_EVENTSETDESCRIPTORS = new EventSetDescriptor[0];

  static final String ADD_PREFIX = "add";
  static final String REMOVE_PREFIX = "remove";
  static final String GET_PREFIX = "get";
  static final String SET_PREFIX = "set";
  static final String IS_PREFIX = "is";

  //======================================================================
  //                          Public methods
  //======================================================================

  /**
   * Introspect on a Java Bean and learn about all its properties, exposed
   * methods, and events.
   * <p>
   * If the BeanInfo class for a Java Bean has been previously Introspected
   * then the BeanInfo class is retrieved from the BeanInfo cache.
   *
   * @param beanClass The bean class to be analyzed.
   * @return A BeanInfo object describing the target bean.
   * @throws IntrospectionException if an exception occurs during introspection.
   * @see #flushCaches
   * @see #flushFromCaches
   */
  public static BeanInfo getBeanInfo(Class<?> beanClass)
      throws IntrospectionException {
    if (!ReflectUtil.isPackageAccessible(beanClass)) {
      return (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo();
    }
    ThreadGroupContext context = ThreadGroupContext.getContext();
    BeanInfo beanInfo;
    synchronized (declaredMethodCache) {
      beanInfo = context.getBeanInfo(beanClass);
    }
    if (beanInfo == null) {
      beanInfo = new Introspector(beanClass, null, USE_ALL_BEANINFO).getBeanInfo();
      synchronized (declaredMethodCache) {
        context.putBeanInfo(beanClass, beanInfo);
      }
    }
    return beanInfo;
  }

  /**
   * Introspect on a Java bean and learn about all its properties, exposed
   * methods, and events, subject to some control flags.
   * <p>
   * If the BeanInfo class for a Java Bean has been previously Introspected
   * based on the same arguments then the BeanInfo class is retrieved
   * from the BeanInfo cache.
   *
   * @param beanClass The bean class to be analyzed.
   * @param flags Flags to control the introspection. If flags == USE_ALL_BEANINFO then we use all
   * of the BeanInfo classes we can discover. If flags == IGNORE_IMMEDIATE_BEANINFO then we ignore
   * any BeanInfo associated with the specified beanClass. If flags == IGNORE_ALL_BEANINFO then we
   * ignore all BeanInfo associated with the specified beanClass or any of its parent classes.
   * @return A BeanInfo object describing the target bean.
   * @throws IntrospectionException if an exception occurs during introspection.
   */
  public static BeanInfo getBeanInfo(Class<?> beanClass, int flags)
      throws IntrospectionException {
    return getBeanInfo(beanClass, null, flags);
  }

  /**
   * Introspect on a Java bean and learn all about its properties, exposed
   * methods, below a given "stop" point.
   * <p>
   * If the BeanInfo class for a Java Bean has been previously Introspected
   * based on the same arguments, then the BeanInfo class is retrieved
   * from the BeanInfo cache.
   *
   * @param beanClass The bean class to be analyzed.
   * @param stopClass The baseclass at which to stop the analysis.  Any methods/properties/events in
   * the stopClass or in its baseclasses will be ignored in the analysis.
   * @return the BeanInfo for the bean
   * @throws IntrospectionException if an exception occurs during introspection.
   */
  public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass)
      throws IntrospectionException {
    return getBeanInfo(beanClass, stopClass, USE_ALL_BEANINFO);
  }

  /**
   * Introspect on a Java Bean and learn about all its properties,
   * exposed methods and events, below a given {@code stopClass} point
   * subject to some control {@code flags}.
   * <dl>
   * <dt>USE_ALL_BEANINFO</dt>
   * <dd>Any BeanInfo that can be discovered will be used.</dd>
   * <dt>IGNORE_IMMEDIATE_BEANINFO</dt>
   * <dd>Any BeanInfo associated with the specified {@code beanClass} will be ignored.</dd>
   * <dt>IGNORE_ALL_BEANINFO</dt>
   * <dd>Any BeanInfo associated with the specified {@code beanClass}
   * or any of its parent classes will be ignored.</dd>
   * </dl>
   * Any methods/properties/events in the {@code stopClass}
   * or in its parent classes will be ignored in the analysis.
   * <p>
   * If the BeanInfo class for a Java Bean has been
   * previously introspected based on the same arguments then
   * the BeanInfo class is retrieved from the BeanInfo cache.
   *
   * @param beanClass the bean class to be analyzed
   * @param stopClass the parent class at which to stop the analysis
   * @param flags flags to control the introspection
   * @return a BeanInfo object describing the target bean
   * @throws IntrospectionException if an exception occurs during introspection
   * @since 1.7
   */
  public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass,
      int flags) throws IntrospectionException {
    BeanInfo bi;
    if (stopClass == null && flags == USE_ALL_BEANINFO) {
      // Same parameters to take advantage of caching.
      bi = getBeanInfo(beanClass);
    } else {
      bi = (new Introspector(beanClass, stopClass, flags)).getBeanInfo();
    }
    return bi;

    // Old behaviour: Make an independent copy of the BeanInfo.
    //return new GenericBeanInfo(bi);
  }


  /**
   * Utility method to take a string and convert it to normal Java variable
   * name capitalization.  This normally means converting the first
   * character from upper case to lower case, but in the (unusual) special
   * case when there is more than one character and both the first and
   * second characters are upper case, we leave it alone.
   * <p>
   * Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays
   * as "URL".
   *
   * @param name The string to be decapitalized.
   * @return The decapitalized version of the string.
   */
  public static String decapitalize(String name) {
    if (name == null || name.length() == 0) {
      return name;
    }
    if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
        Character.isUpperCase(name.charAt(0))) {
      return name;
    }
    char chars[] = name.toCharArray();
    chars[0] = Character.toLowerCase(chars[0]);
    return new String(chars);
  }

  /**
   * Gets the list of package names that will be used for
   * finding BeanInfo classes.
   *
   * @return The array of package names that will be searched in order to find BeanInfo classes. The
   * default value for this array is implementation-dependent; e.g. Sun implementation initially
   * sets to {"sun.beans.infos"}.
   */

  public static String[] getBeanInfoSearchPath() {
    return ThreadGroupContext.getContext().getBeanInfoFinder().getPackages();
  }

  /**
   * Change the list of package names that will be used for
   * finding BeanInfo classes.  The behaviour of
   * this method is undefined if parameter path
   * is null.
   *
   * <p>First, if there is a security manager, its <code>checkPropertiesAccess</code>
   * method is called. This could result in a SecurityException.
   *
   * @param path Array of package names.
   * @throws SecurityException if a security manager exists and its <code>checkPropertiesAccess</code>
   * method doesn't allow setting of system properties.
   * @see SecurityManager#checkPropertiesAccess
   */

  public static void setBeanInfoSearchPath(String[] path) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
      sm.checkPropertiesAccess();
    }
    ThreadGroupContext.getContext().getBeanInfoFinder().setPackages(path);
  }


  /**
   * Flush all of the Introspector's internal caches.  This method is
   * not normally required.  It is normally only needed by advanced
   * tools that update existing "Class" objects in-place and need
   * to make the Introspector re-analyze existing Class objects.
   */

  public static void flushCaches() {
    synchronized (declaredMethodCache) {
      ThreadGroupContext.getContext().clearBeanInfoCache();
      declaredMethodCache.clear();
    }
  }

  /**
   * Flush the Introspector's internal cached information for a given class.
   * This method is not normally required.  It is normally only needed
   * by advanced tools that update existing "Class" objects in-place
   * and need to make the Introspector re-analyze an existing Class object.
   *
   * Note that only the direct state associated with the target Class
   * object is flushed.  We do not flush state for other Class objects
   * with the same name, nor do we flush state for any related Class
   * objects (such as subclasses), even though their state may include
   * information indirectly obtained from the target Class object.
   *
   * @param clz Class object to be flushed.
   * @throws NullPointerException If the Class object is null.
   */
  public static void flushFromCaches(Class<?> clz) {
    if (clz == null) {
      throw new NullPointerException();
    }
    synchronized (declaredMethodCache) {
      ThreadGroupContext.getContext().removeBeanInfo(clz);
      declaredMethodCache.put(clz, null);
    }
  }

  //======================================================================
  //                  Private implementation methods
  //======================================================================

  private Introspector(Class<?> beanClass, Class<?> stopClass, int flags)
      throws IntrospectionException {
    this.beanClass = beanClass;

    // Check stopClass is a superClass of startClass.
    if (stopClass != null) {
      boolean isSuper = false;
      for (Class<?> c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
        if (c == stopClass) {
          isSuper = true;
        }
      }
      if (!isSuper) {
        throw new IntrospectionException(stopClass.getName() + " not superclass of " +
            beanClass.getName());
      }
    }

    if (flags == USE_ALL_BEANINFO) {
      explicitBeanInfo = findExplicitBeanInfo(beanClass);
    }

    Class<?> superClass = beanClass.getSuperclass();
    if (superClass != stopClass) {
      int newFlags = flags;
      if (newFlags == IGNORE_IMMEDIATE_BEANINFO) {
        newFlags = USE_ALL_BEANINFO;
      }
      superBeanInfo = getBeanInfo(superClass, stopClass, newFlags);
    }
    if (explicitBeanInfo != null) {
      additionalBeanInfo = explicitBeanInfo.getAdditionalBeanInfo();
    }
    if (additionalBeanInfo == null) {
      additionalBeanInfo = new BeanInfo[0];
    }
  }

  /**
   * Constructs a GenericBeanInfo class from the state of the Introspector
   */
  private BeanInfo getBeanInfo() throws IntrospectionException {

    // the evaluation order here is import, as we evaluate the
    // event sets and locate PropertyChangeListeners before we
    // look for properties.
    BeanDescriptor bd = getTargetBeanDescriptor();
    MethodDescriptor mds[] = getTargetMethodInfo();
    EventSetDescriptor esds[] = getTargetEventInfo();
    PropertyDescriptor pds[] = getTargetPropertyInfo();

    int defaultEvent = getTargetDefaultEventIndex();
    int defaultProperty = getTargetDefaultPropertyIndex();

    return new GenericBeanInfo(bd, esds, defaultEvent, pds,
        defaultProperty, mds, explicitBeanInfo);

  }

  /**
   * Looks for an explicit BeanInfo class that corresponds to the Class.
   * First it looks in the existing package that the Class is defined in,
   * then it checks to see if the class is its own BeanInfo. Finally,
   * the BeanInfo search path is prepended to the class and searched.
   *
   * @param beanClass the class type of the bean
   * @return Instance of an explicit BeanInfo class or null if one isn't found.
   */
  private static BeanInfo findExplicitBeanInfo(Class<?> beanClass) {
    return ThreadGroupContext.getContext().getBeanInfoFinder().find(beanClass);
  }

  /**
   * @return An array of PropertyDescriptors describing the editable properties supported by the
   * target bean.
   */

  private PropertyDescriptor[] getTargetPropertyInfo() {

    // Check if the bean has its own BeanInfo that will provide
    // explicit information.
    PropertyDescriptor[] explicitProperties = null;
    if (explicitBeanInfo != null) {
      explicitProperties = getPropertyDescriptors(this.explicitBeanInfo);
    }

    if (explicitProperties == null && superBeanInfo != null) {
      // We have no explicit BeanInfo properties.  Check with our parent.
      addPropertyDescriptors(getPropertyDescriptors(this.superBeanInfo));
    }

    for (int i = 0; i < additionalBeanInfo.length; i++) {
      addPropertyDescriptors(additionalBeanInfo[i].getPropertyDescriptors());
    }

    if (explicitProperties != null) {
      // Add the explicit BeanInfo data to our results.
      addPropertyDescriptors(explicitProperties);

    } else {

      // Apply some reflection to the current class.

      // First get an array of all the public methods at this level
      Method methodList[] = getPublicDeclaredMethods(beanClass);

      // Now analyze each method.
      for (int i = 0; i < methodList.length; i++) {
        Method method = methodList[i];
        if (method == null) {
          continue;
        }
        // skip static methods.
        int mods = method.getModifiers();
        if (Modifier.isStatic(mods)) {
          continue;
        }
        String name = method.getName();
        Class<?>[] argTypes = method.getParameterTypes();
        Class<?> resultType = method.getReturnType();
        int argCount = argTypes.length;
        PropertyDescriptor pd = null;

        if (name.length() <= 3 && !name.startsWith(IS_PREFIX)) {
          // Optimization. Don't bother with invalid propertyNames.
          continue;
        }

        try {

          if (argCount == 0) {
            if (name.startsWith(GET_PREFIX)) {
              // Simple getter
              pd = new PropertyDescriptor(this.beanClass, name.substring(3), method, null);
            } else if (resultType == boolean.class && name.startsWith(IS_PREFIX)) {
              // Boolean getter
              pd = new PropertyDescriptor(this.beanClass, name.substring(2), method, null);
            }
          } else if (argCount == 1) {
            if (int.class.equals(argTypes[0]) && name.startsWith(GET_PREFIX)) {
              pd = new IndexedPropertyDescriptor(this.beanClass, name.substring(3), null, null,
                  method, null);
            } else if (void.class.equals(resultType) && name.startsWith(SET_PREFIX)) {
              // Simple setter
              pd = new PropertyDescriptor(this.beanClass, name.substring(3), null, method);
              if (throwsException(method, PropertyVetoException.class)) {
                pd.setConstrained(true);
              }
            }
          } else if (argCount == 2) {
            if (void.class.equals(resultType) && int.class.equals(argTypes[0]) && name
                .startsWith(SET_PREFIX)) {
              pd = new IndexedPropertyDescriptor(this.beanClass, name.substring(3), null, null,
                  null, method);
              if (throwsException(method, PropertyVetoException.class)) {
                pd.setConstrained(true);
              }
            }
          }
        } catch (IntrospectionException ex) {
          // This happens if a PropertyDescriptor or IndexedPropertyDescriptor
          // constructor fins that the method violates details of the deisgn
          // pattern, e.g. by having an empty name, or a getter returning
          // void , or whatever.
          pd = null;
        }

        if (pd != null) {
          // If this class or one of its base classes is a PropertyChange
          // source, then we assume that any properties we discover are "bound".
          if (propertyChangeSource) {
            pd.setBound(true);
          }
          addPropertyDescriptor(pd);
        }
      }
    }
    processPropertyDescriptors();

    // Allocate and populate the result array.
    PropertyDescriptor result[] =
        properties.values().toArray(new PropertyDescriptor[properties.size()]);

    // Set the default index.
    if (defaultPropertyName != null) {
      for (int i = 0; i < result.length; i++) {
        if (defaultPropertyName.equals(result[i].getName())) {
          defaultPropertyIndex = i;
        }
      }
    }

    return result;
  }

  private HashMap<String, List<PropertyDescriptor>> pdStore = new HashMap<>();

  /**
   * Adds the property descriptor to the list store.
   */
  private void addPropertyDescriptor(PropertyDescriptor pd) {
    String propName = pd.getName();
    List<PropertyDescriptor> list = pdStore.get(propName);
    if (list == null) {
      list = new ArrayList<>();
      pdStore.put(propName, list);
    }
    if (this.beanClass != pd.getClass0()) {
      // replace existing property descriptor
      // only if we have types to resolve
      // in the context of this.beanClass
      Method read = pd.getReadMethod();
      Method write = pd.getWriteMethod();
      boolean cls = true;
      if (read != null) {
        cls = cls && read.getGenericReturnType() instanceof Class;
      }
      if (write != null) {
        cls = cls && write.getGenericParameterTypes()[0] instanceof Class;
      }
      if (pd instanceof IndexedPropertyDescriptor) {
        IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
        Method readI = ipd.getIndexedReadMethod();
        Method writeI = ipd.getIndexedWriteMethod();
        if (readI != null) {
          cls = cls && readI.getGenericReturnType() instanceof Class;
        }
        if (writeI != null) {
          cls = cls && writeI.getGenericParameterTypes()[1] instanceof Class;
        }
        if (!cls) {
          pd = new IndexedPropertyDescriptor(ipd);
          pd.updateGenericsFor(this.beanClass);
        }
      } else if (!cls) {
        pd = new PropertyDescriptor(pd);
        pd.updateGenericsFor(this.beanClass);
      }
    }
    list.add(pd);
  }

  private void addPropertyDescriptors(PropertyDescriptor[] descriptors) {
    if (descriptors != null) {
      for (PropertyDescriptor descriptor : descriptors) {
        addPropertyDescriptor(descriptor);
      }
    }
  }

  private PropertyDescriptor[] getPropertyDescriptors(BeanInfo info) {
    PropertyDescriptor[] descriptors = info.getPropertyDescriptors();
    int index = info.getDefaultPropertyIndex();
    if ((0 <= index) && (index < descriptors.length)) {
      this.defaultPropertyName = descriptors[index].getName();
    }
    return descriptors;
  }

  /**
   * Populates the property descriptor table by merging the
   * lists of Property descriptors.
   */
  private void processPropertyDescriptors() {
    if (properties == null) {
      properties = new TreeMap<>();
    }

    List<PropertyDescriptor> list;

    PropertyDescriptor pd, gpd, spd;
    IndexedPropertyDescriptor ipd, igpd, ispd;

    Iterator<List<PropertyDescriptor>> it = pdStore.values().iterator();
    while (it.hasNext()) {
      pd = null;
      gpd = null;
      spd = null;
      ipd = null;
      igpd = null;
      ispd = null;

      list = it.next();

      // First pass. Find the latest getter method. Merge properties
      // of previous getter methods.
      for (int i = 0; i < list.size(); i++) {
        pd = list.get(i);
        if (pd instanceof IndexedPropertyDescriptor) {
          ipd = (IndexedPropertyDescriptor) pd;
          if (ipd.getIndexedReadMethod() != null) {
            if (igpd != null) {
              igpd = new IndexedPropertyDescriptor(igpd, ipd);
            } else {
              igpd = ipd;
            }
          }
        } else {
          if (pd.getReadMethod() != null) {
            String pdName = pd.getReadMethod().getName();
            if (gpd != null) {
              // Don't replace the existing read
              // method if it starts with "is"
              String gpdName = gpd.getReadMethod().getName();
              if (gpdName.equals(pdName) || !gpdName.startsWith(IS_PREFIX)) {
                gpd = new PropertyDescriptor(gpd, pd);
              }
            } else {
              gpd = pd;
            }
          }
        }
      }

      // Second pass. Find the latest setter method which
      // has the same type as the getter method.
      for (int i = 0; i < list.size(); i++) {
        pd = list.get(i);
        if (pd instanceof IndexedPropertyDescriptor) {
          ipd = (IndexedPropertyDescriptor) pd;
          if (ipd.getIndexedWriteMethod() != null) {
            if (igpd != null) {
              if (isAssignable(igpd.getIndexedPropertyType(), ipd.getIndexedPropertyType())) {
                if (ispd != null) {
                  ispd = new IndexedPropertyDescriptor(ispd, ipd);
                } else {
                  ispd = ipd;
                }
              }
            } else {
              if (ispd != null) {
                ispd = new IndexedPropertyDescriptor(ispd, ipd);
              } else {
                ispd = ipd;
              }
            }
          }
        } else {
          if (pd.getWriteMethod() != null) {
            if (gpd != null) {
              if (isAssignable(gpd.getPropertyType(), pd.getPropertyType())) {
                if (spd != null) {
                  spd = new PropertyDescriptor(spd, pd);
                } else {
                  spd = pd;
                }
              }
            } else {
              if (spd != null) {
                spd = new PropertyDescriptor(spd, pd);
              } else {
                spd = pd;
              }
            }
          }
        }
      }

      // At this stage we should have either PDs or IPDs for the
      // representative getters and setters. The order at which the
      // property descriptors are determined represent the
      // precedence of the property ordering.
      pd = null;
      ipd = null;

      if (igpd != null && ispd != null) {
        // Complete indexed properties set
        // Merge any classic property descriptors
        if ((gpd == spd) || (gpd == null)) {
          pd = spd;
        } else if (spd == null) {
          pd = gpd;
        } else if (spd instanceof IndexedPropertyDescriptor) {
          pd = mergePropertyWithIndexedProperty(gpd, (IndexedPropertyDescriptor) spd);
        } else if (gpd instanceof IndexedPropertyDescriptor) {
          pd = mergePropertyWithIndexedProperty(spd, (IndexedPropertyDescriptor) gpd);
        } else {
          pd = mergePropertyDescriptor(gpd, spd);
        }
        if (igpd == ispd) {
          ipd = igpd;
        } else {
          ipd = mergePropertyDescriptor(igpd, ispd);
        }
        if (pd == null) {
          pd = ipd;
        } else {
          Class<?> propType = pd.getPropertyType();
          Class<?> ipropType = ipd.getIndexedPropertyType();
          if (propType.isArray() && propType.getComponentType() == ipropType) {
            pd = pd.getClass0().isAssignableFrom(ipd.getClass0())
                ? new IndexedPropertyDescriptor(pd, ipd)
                : new IndexedPropertyDescriptor(ipd, pd);
          } else if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
            pd = pd.getClass0().isAssignableFrom(ipd.getClass0())
                ? new PropertyDescriptor(pd, ipd)
                : new PropertyDescriptor(ipd, pd);
          } else {
            pd = ipd;
          }
        }
      } else if (gpd != null && spd != null) {
        if (igpd != null) {
          gpd = mergePropertyWithIndexedProperty(gpd, igpd);
        }
        if (ispd != null) {
          spd = mergePropertyWithIndexedProperty(spd, ispd);
        }
        // Complete simple properties set
        if (gpd == spd) {
          pd = gpd;
        } else if (spd instanceof IndexedPropertyDescriptor) {
          pd = mergePropertyWithIndexedProperty(gpd, (IndexedPropertyDescriptor) spd);
        } else if (gpd instanceof IndexedPropertyDescriptor) {
          pd = mergePropertyWithIndexedProperty(spd, (IndexedPropertyDescriptor) gpd);
        } else {
          pd = mergePropertyDescriptor(gpd, spd);
        }
      } else if (ispd != null) {
        // indexed setter
        pd = ispd;
        // Merge any classic property descriptors
        if (spd != null) {
          pd = mergePropertyDescriptor(ispd, spd);
        }
        if (gpd != null) {
          pd = mergePropertyDescriptor(ispd, gpd);
        }
      } else if (igpd != null) {
        // indexed getter
        pd = igpd;
        // Merge any classic property descriptors
        if (gpd != null) {
          pd = mergePropertyDescriptor(igpd, gpd);
        }
        if (spd != null) {
          pd = mergePropertyDescriptor(igpd, spd);
        }
      } else if (spd != null) {
        // simple setter
        pd = spd;
      } else if (gpd != null) {
        // simple getter
        pd = gpd;
      }

      // Very special case to ensure that an IndexedPropertyDescriptor
      // doesn't contain less information than the enclosed
      // PropertyDescriptor. If it does, then recreate as a
      // PropertyDescriptor. See 4168833
      if (pd instanceof IndexedPropertyDescriptor) {
        ipd = (IndexedPropertyDescriptor) pd;
        if (ipd.getIndexedReadMethod() == null && ipd.getIndexedWriteMethod() == null) {
          pd = new PropertyDescriptor(ipd);
        }
      }

      // Find the first property descriptor
      // which does not have getter and setter methods.
      // See regression bug 4984912.
      if ((pd == null) && (list.size() > 0)) {
        pd = list.get(0);
      }

      if (pd != null) {
        properties.put(pd.getName(), pd);
      }
    }
  }

  private static boolean isAssignable(Class<?> current, Class<?> candidate) {
    return ((current == null) || (candidate == null)) ? current == candidate
        : current.isAssignableFrom(candidate);
  }

  private PropertyDescriptor mergePropertyWithIndexedProperty(PropertyDescriptor pd,
      IndexedPropertyDescriptor ipd) {
    Class<?> type = pd.getPropertyType();
    if (type.isArray() && (type.getComponentType() == ipd.getIndexedPropertyType())) {
      return pd.getClass0().isAssignableFrom(ipd.getClass0())
          ? new IndexedPropertyDescriptor(pd, ipd)
          : new IndexedPropertyDescriptor(ipd, pd);
    }
    return pd;
  }

  /**
   * Adds the property descriptor to the indexedproperty descriptor only if the
   * types are the same.
   *
   * The most specific property descriptor will take precedence.
   */
  private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,
      PropertyDescriptor pd) {
    PropertyDescriptor result = null;

    Class<?> propType = pd.getPropertyType();
    Class<?> ipropType = ipd.getIndexedPropertyType();

    if (propType.isArray() && propType.getComponentType() == ipropType) {
      if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
        result = new IndexedPropertyDescriptor(pd, ipd);
      } else {
        result = new IndexedPropertyDescriptor(ipd, pd);
      }
    } else if ((ipd.getReadMethod() == null) && (ipd.getWriteMethod() == null)) {
      if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
        result = new PropertyDescriptor(pd, ipd);
      } else {
        result = new PropertyDescriptor(ipd, pd);
      }
    } else {
      // Cannot merge the pd because of type mismatch
      // Return the most specific pd
      if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
        result = ipd;
      } else {
        result = pd;
        // Try to add methods which may have been lost in the type change
        // See 4168833
        Method write = result.getWriteMethod();
        Method read = result.getReadMethod();

        if (read == null && write != null) {
          read = findMethod(result.getClass0(),
              GET_PREFIX + NameGenerator.capitalize(result.getName()), 0);
          if (read != null) {
            try {
              result.setReadMethod(read);
            } catch (IntrospectionException ex) {
              // no consequences for failure.
            }
          }
        }
        if (write == null && read != null) {
          write = findMethod(result.getClass0(),
              SET_PREFIX + NameGenerator.capitalize(result.getName()), 1,
              new Class<?>[]{FeatureDescriptor.getReturnType(result.getClass0(), read)});
          if (write != null) {
            try {
              result.setWriteMethod(write);
            } catch (IntrospectionException ex) {
              // no consequences for failure.
            }
          }
        }
      }
    }
    return result;
  }

  // Handle regular pd merge
  private PropertyDescriptor mergePropertyDescriptor(PropertyDescriptor pd1,
      PropertyDescriptor pd2) {
    if (pd1.getClass0().isAssignableFrom(pd2.getClass0())) {
      return new PropertyDescriptor(pd1, pd2);
    } else {
      return new PropertyDescriptor(pd2, pd1);
    }
  }

  // Handle regular ipd merge
  private IndexedPropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd1,
      IndexedPropertyDescriptor ipd2) {
    if (ipd1.getClass0().isAssignableFrom(ipd2.getClass0())) {
      return new IndexedPropertyDescriptor(ipd1, ipd2);
    } else {
      return new IndexedPropertyDescriptor(ipd2, ipd1);
    }
  }

  /**
   * @return An array of EventSetDescriptors describing the kinds of events fired by the target
   * bean.
   */
  private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
    if (events == null) {
      events = new HashMap<>();
    }

    // Check if the bean has its own BeanInfo that will provide
    // explicit information.
    EventSetDescriptor[] explicitEvents = null;
    if (explicitBeanInfo != null) {
      explicitEvents = explicitBeanInfo.getEventSetDescriptors();
      int ix = explicitBeanInfo.getDefaultEventIndex();
      if (ix >= 0 && ix < explicitEvents.length) {
        defaultEventName = explicitEvents[ix].getName();
      }
    }

    if (explicitEvents == null && superBeanInfo != null) {
      // We have no explicit BeanInfo events.  Check with our parent.
      EventSetDescriptor supers[] = superBeanInfo.getEventSetDescriptors();
      for (int i = 0; i < supers.length; i++) {
        addEvent(supers[i]);
      }
      int ix = superBeanInfo.getDefaultEventIndex();
      if (ix >= 0 && ix < supers.length) {
        defaultEventName = supers[ix].getName();
      }
    }

    for (int i = 0; i < additionalBeanInfo.length; i++) {
      EventSetDescriptor additional[] = additionalBeanInfo[i].getEventSetDescriptors();
      if (additional != null) {
        for (int j = 0; j < additional.length; j++) {
          addEvent(additional[j]);
        }
      }
    }

    if (explicitEvents != null) {
      // Add the explicit explicitBeanInfo data to our results.
      for (int i = 0; i < explicitEvents.length; i++) {
        addEvent(explicitEvents[i]);
      }

    } else {

      // Apply some reflection to the current class.

      // Get an array of all the public beans methods at this level
      Method methodList[] = getPublicDeclaredMethods(beanClass);

      // Find all suitable "add", "remove" and "get" Listener methods
      // The name of the listener type is the key for these hashtables
      // i.e, ActionListener
      Map<String, Method> adds = null;
      Map<String, Method> removes = null;
      Map<String, Method> gets = null;

      for (int i = 0; i < methodList.length; i++) {
        Method method = methodList[i];
        if (method == null) {
          continue;
        }
        // skip static methods.
        int mods = method.getModifiers();
        if (Modifier.isStatic(mods)) {
          continue;
        }
        String name = method.getName();
        // Optimization avoid getParameterTypes
        if (!name.startsWith(ADD_PREFIX) && !name.startsWith(REMOVE_PREFIX)
            && !name.startsWith(GET_PREFIX)) {
          continue;
        }

        if (name.startsWith(ADD_PREFIX)) {
          Class<?> returnType = method.getReturnType();
          if (returnType == void.class) {
            Type[] parameterTypes = method.getGenericParameterTypes();
            if (parameterTypes.length == 1) {
              Class<?> type = TypeResolver
                  .erase(TypeResolver.resolveInClass(beanClass, parameterTypes[0]));
              if (Introspector.isSubclass(type, eventListenerType)) {
                String listenerName = name.substring(3);
                if (listenerName.length() > 0 &&
                    type.getName().endsWith(listenerName)) {
                  if (adds == null) {
                    adds = new HashMap<>();
                  }
                  adds.put(listenerName, method);
                }
              }
            }
          }
        } else if (name.startsWith(REMOVE_PREFIX)) {
          Class<?> returnType = method.getReturnType();
          if (returnType == void.class) {
            Type[] parameterTypes = method.getGenericParameterTypes();
            if (parameterTypes.length == 1) {
              Class<?> type = TypeResolver
                  .erase(TypeResolver.resolveInClass(beanClass, parameterTypes[0]));
              if (Introspector.isSubclass(type, eventListenerType)) {
                String listenerName = name.substring(6);
                if (listenerName.length() > 0 &&
                    type.getName().endsWith(listenerName)) {
                  if (removes == null) {
                    removes = new HashMap<>();
                  }
                  removes.put(listenerName, method);
                }
              }
            }
          }
        } else if (name.startsWith(GET_PREFIX)) {
          Class<?>[] parameterTypes = method.getParameterTypes();
          if (parameterTypes.length == 0) {
            Class<?> returnType = FeatureDescriptor.getReturnType(beanClass, method);
            if (returnType.isArray()) {
              Class<?> type = returnType.getComponentType();
              if (Introspector.isSubclass(type, eventListenerType)) {
                String listenerName = name.substring(3, name.length() - 1);
                if (listenerName.length() > 0 &&
                    type.getName().endsWith(listenerName)) {
                  if (gets == null) {
                    gets = new HashMap<>();
                  }
                  gets.put(listenerName, method);
                }
              }
            }
          }
        }
      }

      if (adds != null && removes != null) {
        // Now look for matching addFooListener+removeFooListener pairs.
        // Bonus if there is a matching getFooListeners method as well.
        Iterator<String> keys = adds.keySet().iterator();
        while (keys.hasNext()) {
          String listenerName = keys.next();
          // Skip any "add" which doesn't have a matching "remove" or
          // a listener name that doesn't end with Listener
          if (removes.get(listenerName) == null || !listenerName.endsWith("Listener")) {
            continue;
          }
          String eventName = decapitalize(listenerName.substring(0, listenerName.length() - 8));
          Method addMethod = adds.get(listenerName);
          Method removeMethod = removes.get(listenerName);
          Method getMethod = null;
          if (gets != null) {
            getMethod = gets.get(listenerName);
          }
          Class<?> argType = FeatureDescriptor.getParameterTypes(beanClass, addMethod)[0];

          // generate a list of Method objects for each of the target methods:
          Method allMethods[] = getPublicDeclaredMethods(argType);
          List<Method> validMethods = new ArrayList<>(allMethods.length);
          for (int i = 0; i < allMethods.length; i++) {
            if (allMethods[i] == null) {
              continue;
            }

            if (isEventHandler(allMethods[i])) {
              validMethods.add(allMethods[i]);
            }
          }
          Method[] methods = validMethods.toArray(new Method[validMethods.size()]);

          EventSetDescriptor esd = new EventSetDescriptor(eventName, argType,
              methods, addMethod,
              removeMethod,
              getMethod);

          // If the adder method throws the TooManyListenersException then it
          // is a Unicast event source.
          if (throwsException(addMethod,
              java.util.TooManyListenersException.class)) {
            esd.setUnicast(true);
          }
          addEvent(esd);
        }
      } // if (adds != null ...
    }
    EventSetDescriptor[] result;
    if (events.size() == 0) {
      result = EMPTY_EVENTSETDESCRIPTORS;
    } else {
      // Allocate and populate the result array.
      result = new EventSetDescriptor[events.size()];
      result = events.values().toArray(result);

      // Set the default index.
      if (defaultEventName != null) {
        for (int i = 0; i < result.length; i++) {
          if (defaultEventName.equals(result[i].getName())) {
            defaultEventIndex = i;
          }
        }
      }
    }
    return result;
  }

  private void addEvent(EventSetDescriptor esd) {
    String key = esd.getName();
    if (esd.getName().equals("propertyChange")) {
      propertyChangeSource = true;
    }
    EventSetDescriptor old = events.get(key);
    if (old == null) {
      events.put(key, esd);
      return;
    }
    EventSetDescriptor composite = new EventSetDescriptor(old, esd);
    events.put(key, composite);
  }

  /**
   * @return An array of MethodDescriptors describing the private methods supported by the target
   * bean.
   */
  private MethodDescriptor[] getTargetMethodInfo() {
    if (methods == null) {
      methods = new HashMap<>(100);
    }

    // Check if the bean has its own BeanInfo that will provide
    // explicit information.
    MethodDescriptor[] explicitMethods = null;
    if (explicitBeanInfo != null) {
      explicitMethods = explicitBeanInfo.getMethodDescriptors();
    }

    if (explicitMethods == null && superBeanInfo != null) {
      // We have no explicit BeanInfo methods.  Check with our parent.
      MethodDescriptor supers[] = superBeanInfo.getMethodDescriptors();
      for (int i = 0; i < supers.length; i++) {
        addMethod(supers[i]);
      }
    }

    for (int i = 0; i < additionalBeanInfo.length; i++) {
      MethodDescriptor additional[] = additionalBeanInfo[i].getMethodDescriptors();
      if (additional != null) {
        for (int j = 0; j < additional.length; j++) {
          addMethod(additional[j]);
        }
      }
    }

    if (explicitMethods != null) {
      // Add the explicit explicitBeanInfo data to our results.
      for (int i = 0; i < explicitMethods.length; i++) {
        addMethod(explicitMethods[i]);
      }

    } else {

      // Apply some reflection to the current class.

      // First get an array of all the beans methods at this level
      Method methodList[] = getPublicDeclaredMethods(beanClass);

      // Now analyze each method.
      for (int i = 0; i < methodList.length; i++) {
        Method method = methodList[i];
        if (method == null) {
          continue;
        }
        MethodDescriptor md = new MethodDescriptor(method);
        addMethod(md);
      }
    }

    // Allocate and populate the result array.
    MethodDescriptor result[] = new MethodDescriptor[methods.size()];
    result = methods.values().toArray(result);

    return result;
  }

  private void addMethod(MethodDescriptor md) {
    // We have to be careful here to distinguish method by both name
    // and argument lists.
    // This method gets called a *lot, so we try to be efficient.
    String name = md.getName();

    MethodDescriptor old = methods.get(name);
    if (old == null) {
      // This is the common case.
      methods.put(name, md);
      return;
    }

    // We have a collision on method names.  This is rare.

    // Check if old and md have the same type.
    String[] p1 = md.getParamNames();
    String[] p2 = old.getParamNames();

    boolean match = false;
    if (p1.length == p2.length) {
      match = true;
      for (int i = 0; i < p1.length; i++) {
        if (p1[i] != p2[i]) {
          match = false;
          break;
        }
      }
    }
    if (match) {
      MethodDescriptor composite = new MethodDescriptor(old, md);
      methods.put(name, composite);
      return;
    }

    // We have a collision on method names with different type signatures.
    // This is very rare.

    String longKey = makeQualifiedMethodName(name, p1);
    old = methods.get(longKey);
    if (old == null) {
      methods.put(longKey, md);
      return;
    }
    MethodDescriptor composite = new MethodDescriptor(old, md);
    methods.put(longKey, composite);
  }

  /**
   * Creates a key for a method in a method cache.
   */
  private static String makeQualifiedMethodName(String name, String[] params) {
    StringBuffer sb = new StringBuffer(name);
    sb.append('=');
    for (int i = 0; i < params.length; i++) {
      sb.append(':');
      sb.append(params[i]);
    }
    return sb.toString();
  }

  private int getTargetDefaultEventIndex() {
    return defaultEventIndex;
  }

  private int getTargetDefaultPropertyIndex() {
    return defaultPropertyIndex;
  }

  private BeanDescriptor getTargetBeanDescriptor() {
    // Use explicit info, if available,
    if (explicitBeanInfo != null) {
      BeanDescriptor bd = explicitBeanInfo.getBeanDescriptor();
      if (bd != null) {
        return (bd);
      }
    }
    // OK, fabricate a default BeanDescriptor.
    return new BeanDescriptor(this.beanClass, findCustomizerClass(this.beanClass));
  }

  private static Class<?> findCustomizerClass(Class<?> type) {
    String name = type.getName() + "Customizer";
    try {
      type = ClassFinder.findClass(name, type.getClassLoader());
      // Each customizer should inherit java.awt.Component and implement java.beans.Customizer
      // according to the section 9.3 of JavaBeans&trade; specification
      if (Component.class.isAssignableFrom(type) && Customizer.class.isAssignableFrom(type)) {
        return type;
      }
    } catch (Exception exception) {
      // ignore any exceptions
    }
    return null;
  }

  private boolean isEventHandler(Method m) {
    // We assume that a method is an event handler if it has a single
    // argument, whose type inherit from java.util.Event.
    Type argTypes[] = m.getGenericParameterTypes();
    if (argTypes.length != 1) {
      return false;
    }
    return isSubclass(TypeResolver.erase(TypeResolver.resolveInClass(beanClass, argTypes[0])),
        EventObject.class);
  }

  /*
   * Internal method to return *public* methods within a class.
   */
  private static Method[] getPublicDeclaredMethods(Class<?> clz) {
    // Looking up Class.getDeclaredMethods is relatively expensive,
    // so we cache the results.
    if (!ReflectUtil.isPackageAccessible(clz)) {
      return new Method[0];
    }
    synchronized (declaredMethodCache) {
      Method[] result = declaredMethodCache.get(clz);
      if (result == null) {
        result = clz.getMethods();
        for (int i = 0; i < result.length; i++) {
          Method method = result[i];
          if (!method.getDeclaringClass().equals(clz)) {
            result[i] = null; // ignore methods declared elsewhere
          } else {
            try {
              method = MethodFinder.findAccessibleMethod(method);
              Class<?> type = method.getDeclaringClass();
              result[i] = type.equals(clz) || type.isInterface()
                  ? method
                  : null; // ignore methods from superclasses
            } catch (NoSuchMethodException exception) {
              // commented out because of 6976577
              // result[i] = null; // ignore inaccessible methods
            }
          }
        }
        declaredMethodCache.put(clz, result);
      }
      return result;
    }
  }

  //======================================================================
  // Package private support methods.
  //======================================================================

  /**
   * Internal support for finding a target methodName with a given
   * parameter list on a given class.
   */
  private static Method internalFindMethod(Class<?> start, String methodName,
      int argCount, Class args[]) {
    // For overriden methods we need to find the most derived version.
    // So we start with the given class and walk up the superclass chain.

    Method method = null;

    for (Class<?> cl = start; cl != null; cl = cl.getSuperclass()) {
      Method methods[] = getPublicDeclaredMethods(cl);
      for (int i = 0; i < methods.length; i++) {
        method = methods[i];
        if (method == null) {
          continue;
        }

        // make sure method signature matches.
        if (method.getName().equals(methodName)) {
          Type[] params = method.getGenericParameterTypes();
          if (params.length == argCount) {
            if (args != null) {
              boolean different = false;
              if (argCount > 0) {
                for (int j = 0; j < argCount; j++) {
                  if (TypeResolver.erase(TypeResolver.resolveInClass(start, params[j]))
                      != args[j]) {
                    different = true;
                    continue;
                  }
                }
                if (different) {
                  continue;
                }
              }
            }
            return method;
          }
        }
      }
    }
    method = null;

    // Now check any inherited interfaces.  This is necessary both when
    // the argument class is itself an interface, and when the argument
    // class is an abstract class.
    Class ifcs[] = start.getInterfaces();
    for (int i = 0; i < ifcs.length; i++) {
      // Note: The original implementation had both methods calling
      // the 3 arg method. This is preserved but perhaps it should
      // pass the args array instead of null.
      method = internalFindMethod(ifcs[i], methodName, argCount, null);
      if (method != null) {
        break;
      }
    }
    return method;
  }

  /**
   * Find a target methodName on a given class.
   */
  static Method findMethod(Class<?> cls, String methodName, int argCount) {
    return findMethod(cls, methodName, argCount, null);
  }

  /**
   * Find a target methodName with specific parameter list on a given class.
   * <p>
   * Used in the contructors of the EventSetDescriptor,
   * PropertyDescriptor and the IndexedPropertyDescriptor.
   * <p>
   *
   * @param cls The Class object on which to retrieve the method.
   * @param methodName Name of the method.
   * @param argCount Number of arguments for the desired method.
   * @param args Array of argument types for the method.
   * @return the method or null if not found
   */
  static Method findMethod(Class<?> cls, String methodName, int argCount,
      Class args[]) {
    if (methodName == null) {
      return null;
    }
    return internalFindMethod(cls, methodName, argCount, args);
  }

  /**
   * Return true if class a is either equivalent to class b, or
   * if class a is a subclass of class b, i.e. if a either "extends"
   * or "implements" b.
   * Note tht either or both "Class" objects may represent interfaces.
   */
  static boolean isSubclass(Class<?> a, Class<?> b) {
    // We rely on the fact that for any given java class or
    // primtitive type there is a unqiue Class object, so
    // we can use object equivalence in the comparisons.
    if (a == b) {
      return true;
    }
    if (a == null || b == null) {
      return false;
    }
    for (Class<?> x = a; x != null; x = x.getSuperclass()) {
      if (x == b) {
        return true;
      }
      if (b.isInterface()) {
        Class<?>[] interfaces = x.getInterfaces();
        for (int i = 0; i < interfaces.length; i++) {
          if (isSubclass(interfaces[i], b)) {
            return true;
          }
        }
      }
    }
    return false;
  }

  /**
   * Return true iff the given method throws the given exception.
   */
  private boolean throwsException(Method method, Class<?> exception) {
    Class exs[] = method.getExceptionTypes();
    for (int i = 0; i < exs.length; i++) {
      if (exs[i] == exception) {
        return true;
      }
    }
    return false;
  }

  /**
   * Try to create an instance of a named class.
   * First try the classloader of "sibling", then try the system
   * classloader then the class loader of the current Thread.
   */
  static Object instantiate(Class<?> sibling, String className)
      throws InstantiationException, IllegalAccessException,
      ClassNotFoundException {
    // First check with sibling's classloader (if any).
    ClassLoader cl = sibling.getClassLoader();
    Class<?> cls = ClassFinder.findClass(className, cl);
    return cls.newInstance();
  }

} // end class Introspector

//===========================================================================

/**
 * Package private implementation support class for Introspector's
 * internal use.
 * <p>
 * Mostly this is used as a placeholder for the descriptors.
 */

class GenericBeanInfo extends SimpleBeanInfo {

  private BeanDescriptor beanDescriptor;
  private EventSetDescriptor[] events;
  private int defaultEvent;
  private PropertyDescriptor[] properties;
  private int defaultProperty;
  private MethodDescriptor[] methods;
  private Reference<BeanInfo> targetBeanInfoRef;

  public GenericBeanInfo(BeanDescriptor beanDescriptor,
      EventSetDescriptor[] events, int defaultEvent,
      PropertyDescriptor[] properties, int defaultProperty,
      MethodDescriptor[] methods, BeanInfo targetBeanInfo) {
    this.beanDescriptor = beanDescriptor;
    this.events = events;
    this.defaultEvent = defaultEvent;
    this.properties = properties;
    this.defaultProperty = defaultProperty;
    this.methods = methods;
    this.targetBeanInfoRef = (targetBeanInfo != null)
        ? new SoftReference<>(targetBeanInfo)
        : null;
  }

  /**
   * Package-private dup constructor
   * This must isolate the new object from any changes to the old object.
   */
  GenericBeanInfo(GenericBeanInfo old) {

    beanDescriptor = new BeanDescriptor(old.beanDescriptor);
    if (old.events != null) {
      int len = old.events.length;
      events = new EventSetDescriptor[len];
      for (int i = 0; i < len; i++) {
        events[i] = new EventSetDescriptor(old.events[i]);
      }
    }
    defaultEvent = old.defaultEvent;
    if (old.properties != null) {
      int len = old.properties.length;
      properties = new PropertyDescriptor[len];
      for (int i = 0; i < len; i++) {
        PropertyDescriptor oldp = old.properties[i];
        if (oldp instanceof IndexedPropertyDescriptor) {
          properties[i] = new IndexedPropertyDescriptor(
              (IndexedPropertyDescriptor) oldp);
        } else {
          properties[i] = new PropertyDescriptor(oldp);
        }
      }
    }
    defaultProperty = old.defaultProperty;
    if (old.methods != null) {
      int len = old.methods.length;
      methods = new MethodDescriptor[len];
      for (int i = 0; i < len; i++) {
        methods[i] = new MethodDescriptor(old.methods[i]);
      }
    }
    this.targetBeanInfoRef = old.targetBeanInfoRef;
  }

  public PropertyDescriptor[] getPropertyDescriptors() {
    return properties;
  }

  public int getDefaultPropertyIndex() {
    return defaultProperty;
  }

  public EventSetDescriptor[] getEventSetDescriptors() {
    return events;
  }

  public int getDefaultEventIndex() {
    return defaultEvent;
  }

  public MethodDescriptor[] getMethodDescriptors() {
    return methods;
  }

  public BeanDescriptor getBeanDescriptor() {
    return beanDescriptor;
  }

  public java.awt.Image getIcon(int iconKind) {
    BeanInfo targetBeanInfo = getTargetBeanInfo();
    if (targetBeanInfo != null) {
      return targetBeanInfo.getIcon(iconKind);
    }
    return super.getIcon(iconKind);
  }

  private BeanInfo getTargetBeanInfo() {
    if (this.targetBeanInfoRef == null) {
      return null;
    }
    BeanInfo targetBeanInfo = this.targetBeanInfoRef.get();
    if (targetBeanInfo == null) {
      targetBeanInfo = ThreadGroupContext.getContext().getBeanInfoFinder()
          .find(this.beanDescriptor.getBeanClass());
      if (targetBeanInfo != null) {
        this.targetBeanInfoRef = new SoftReference<>(targetBeanInfo);
      }
    }
    return targetBeanInfo;
  }
}
